package com.maheimei.controller;

import com.alibaba.fastjson.JSON;
import com.maheimei.entity.User;
import org.apache.commons.io.FileUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.*;

import static org.springframework.util.StringUtils.getFilename;


//@CrossOrigin
@Controller
public class UserControllertwo {
    /**
     * 原生参数接收
     * @param request 原生请求
     * @param response 原生响应
     * @param session 原生会话
     * @return 页面名称
     */
    @RequestMapping("/index1")
    public String show1(HttpServletRequest request, HttpServletResponse response, HttpSession session){
        String username = request.getParameter("username");
        String age = request.getParameter("age");
        System.out.println(username);
        System.out.println(age);
        System.out.println("123");
        System.out.println("343");
        return "index.html";
    }

    /**
     * 形参接收
     * @param username 用户名
     * @param age 年龄
     * @return 页面名称
     * 页面中提供的参数可以直接绑定在形参中，直接使用形参接收即可，并且数据类型也可以帮助我进行转换，但是如果类型不匹配，会报错
     * 注意：页面中传递的参数key必须和方法形参的变量名一致，否则无法接收到参数
     */
    @RequestMapping("/index2")
    public String show2(String username, int age){
        System.out.println(username);
        System.out.println(age+5);
        return "index.html";
    }

    /**
     * @RequestParam注解
     * @param username
     * @param age
     * @return
     *
     * 注意：当页面中传递的参数key与方法形参名不一致，可以通过@RequestParam注解来指定参数名，但是注意：如果参数名一致，则无需指定@RequestParam注解，直接使用形参接收即可
     */
    @RequestMapping("/index3")
    public String show3(@RequestParam("name") String username, @RequestParam("userage") int age){
        System.out.println(username);
        System.out.println(age+5);
        return "index.html";
    }

    /**
     * 形参接收对象
     * @param u
     * @return
     * 注意：形参接收对象，对象中的属性名必须和页面中传递的参数名一致，否则接收不到参数，并且数据类型也必须一致，否则接收不到参数
     */
    @RequestMapping("/index4")
    public String show4(User u){
        System.out.println("-----index4");
        System.out.println(u.getUsername());
        System.out.println(u.getAge());
        return "index.html";
    }

    /**
     * 形参接收对象，同时接受一个变量
     * @param u
     * @param hobby
     * @return
     *
     * 注意：这没什么可注意的
     */
    @RequestMapping("/index5")
    public String show5(User u, String hobby){
        System.out.println("-----index5");
        System.out.println(u.getUsername());
        System.out.println(u.getAge());
        System.out.println(hobby);
        return "index.html";
    }

    /**
     * 形参接收数组
     * @param hobby
     * @return
     *
     * 注意：页面中会传递相同key的参数，例如：hobby=a&hobby=b&hobby=c，此时hobby是一个数组，数组中存放了所有的hobby值
     */
    @RequestMapping("/index6")
    public String show6(String[] hobby){
        System.out.println("-----index6");
        System.out.println(Arrays.toString(hobby));
        return "index.html";
    }

    /**
     * 形参接收集合
     * @param hobby
     * @return
     *
     * 注意：当方法形参为集合类型时，SpringMVC会将它视作对象进行处理，所以在接受页面中参数的时候，需要使用@RequestParam注解来指定参数名，否则会报错
     */
    @RequestMapping("/index7")
    public String show7(@RequestParam("hobby") ArrayList<String> hobby){
        System.out.println("-----index7");
        System.out.println(hobby.toString());
        return "index.html";
    }

    /**
     * 形参接收对象集合
     * @param users
     * @return
     *
     * 注意：通常在接受对象集合时，前端传递的参数都是JSON类型的，所以使用@RequestBody注解标记接受的是纯文本信息
     */
    @RequestMapping("/index8")
    public String show8(@RequestBody ArrayList<User> users){
        System.out.println("-----index8");
        System.out.println(users.toString());
        return "index.html";
    }

    /**
     * 使用forward转发
     * @param u
     * @return
     *
     *
     */
    @RequestMapping("/index9")
    public String show9(User u){
        System.out.println("-----index9");
        System.out.println(u.toString());
        return "forward:index.html";
    }

    /**
     * 使用redirect重定向
     * @param u
     * @return
     *
     */
    @RequestMapping("/index10")
    public String show10(User u){
        System.out.println("-----index10");
        System.out.println(u.toString());
        return "redirect:index.html";
    }

    /**
     * 使用ModelAndView作为响应内容
     * @param u
     * @return
     *
     * 比较古老，并且无法用在前后端分离的模式中
     */
    @RequestMapping("/index11")
    public ModelAndView show11(User u){
        ModelAndView mav = new ModelAndView();
        mav.addObject("user", u);
        mav.setViewName("index.html");
        return mav;
    }

    /**
     * 使用@ResponseBody注解返回JSON
     * @param u
     * @return
     *
     * 最常使用，也是前后端分离模式中最重要的数据传输方式
     */
    @ResponseBody
    @RequestMapping(value = "/index12", method = RequestMethod.POST)
    public String show12(User u){
        // JSON.parseObject("前端或数据库中取出的JSON字符串", User.class); JSON转对象，通常是后台用
        User user = JSON.parseObject("{\"username\":\"张三\",\"age\":18}", User.class);
        System.out.println(user.getUsername());
        System.out.println(user.getAge());

        // JSON.toJSONString(对象); 对象转JSON字符串，通常是后台给前端响应时用
        // String jsonString = JSON.toJSONString(u);
        return JSON.toJSONString(u);
    }

    @ResponseBody
    @RequestMapping("/fileupload")
    public String show13(MultipartFile uploadfile){
        System.out.println("-----fileupload"+uploadfile.getName());
        System.out.println(uploadfile.getSize());
        //获取文件名称
        String filename = uploadfile.getOriginalFilename();
        //存在服务器上名称的修改
        filename = UUID.randomUUID()+filename;
        // 定义服务器上的存储路径
        String dirPath = "G:/file/";
        File filePath = new File(dirPath);
        // 判断路径是否存在,不存在就创建
        if(!filePath.exists()){
            filePath.mkdir();
        }
        try {
            // 文件上传的核心
            uploadfile.transferTo(new File(dirPath+filename));
        } catch (IOException e) {
            e.printStackTrace();
            return "失败";
        }
        return "成功";
    }

    @RequestMapping("/download")
    public ResponseEntity<byte[]> fileDownload(String filename) throws UnsupportedEncodingException {
        //指定文件下载地址的目录   filename -> 美女.jpg
        String dirPath = "G:/file/";
        // 指定下载的文件名称
        File file = new File(dirPath+filename);
        HttpHeaders headers = new HttpHeaders();
        //告诉浏览器，打开方式（附件）
        headers.setContentDispositionFormData("attachment",filename);
        //以二进制字节流的方式下载
        headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
        try {
            return new ResponseEntity<>(FileUtils.readFileToByteArray(file),headers, HttpStatus.OK);
        } catch (IOException e) {
            e.printStackTrace();
            return new ResponseEntity<>(e.getMessage().getBytes(), HttpStatus.EXPECTATION_FAILED);
        }
    }

/*
    @RequestMapping("/index1")
    public String show1(HttpServletRequest request, HttpServletResponse response, HttpSession session){
        System.out.println("index1----");
        String name = request.getParameter("name");
        System.out.println(name);
        return "index.html";
    }

    @RequestMapping("/index2")
    public String show2(@RequestParam("username") String name, int age){
        System.out.println("index2----");
        System.out.println(name+age);
        System.out.println(age+1);
        return "index.html";
    }

    @RequestMapping("/index3")
    public String show3(User u){
        System.out.println("index3----");
        System.out.println(u.getUsername());
        System.out.println(u.getAge());
        return "index.html";
    }

    // /index4?names=张三&names=李四
    @RequestMapping("/index4")
    public String show4(@RequestParam("names") List<String> names){
        System.out.println("index4----");
        for (String name:names){
            System.out.println(name);
        }
        return "index.html";
    }

    // /index5?names=张三&names=李四
    @RequestMapping("/index5")
    public String show5(String[] names){
        System.out.println("index5----");
        for (String name:names){
            System.out.println(name);
        }
        return "index.html";
    }

    // /index6?names=张三&names=李四
    @RequestMapping("/index6")
    public String show6(@RequestBody List<User> users){
        System.out.println("index6----");
        for (User u:users){
            System.out.println(u.getUsername());
        }
        return "index.html";
    }

    @ResponseBody
    @RequestMapping("/index7")
    public String show7(User u){
        System.out.println(u.getUsername());
        System.out.println(u.getAge());
        // JSON.parseObject("前端或数据库中取出的JSON字符串", User.class); JSON转对象，通常是后台用
        // User user = JSON.parseObject("{\"username\":\"张三\",\"age\":18}", User.class);

        // JSON.toJSONString(对象); 对象转JSON字符串，通常是后台给前端响应时用
        // String jsonString = JSON.toJSONString(u);
        return JSON.toJSONString(u);
    }

    @RequestMapping("/index8")
    public ModelAndView show8(User u){
        ModelAndView mav = new ModelAndView();
        mav.addObject("user", u);
        mav.setViewName("index.html");
        return mav;
    }
    @RequestMapping("/index9")
    public String show9(User u){
        System.out.println(u.getUsername());
        System.out.println(u.getAge());
        return "forward:index.html";
    }
    @RequestMapping("/index10")
    public String show10(User u){
        System.out.println(u.getUsername());
        System.out.println(u.getAge());
        return "redirect:index.html";
    }*/
}
